package org.learn;

import java.util.concurrent.ArrayBlockingQueue;
import java.util.concurrent.SynchronousQueue;
import java.util.concurrent.ThreadPoolExecutor;
import java.util.concurrent.TimeUnit;

/**
 * @Auther: qingle
 * @Date: 2024/9/8-23:50
 * @Description: 直接提交队列 SynchronousQueue
 *
 * SynchronousQueue
 * 1. SynchronousQueue 不存放任务，直接将任务交给线程池中的非核心线程执行，线程池中的线程执行完任务后，会一直等待，直到有新的任务到来，才会继续执行。
 *
 * 2. SynchronousQueue 是一个特殊的阻塞队列，它不会缓存任务，也不会对任务进行存储。当一个线程尝试向 SynchronousQueue 中添加一个任务时，如果当前没有线程在等待接收任务，
 * 则该任务会被拒绝。
 * 3. SynchronousQueue 的特性使得它特别适合于需要实时处理任务的场景，例如在消息队列中，当一个消息被发送到队列中时，需要立即被消费，而不需要等待其他消息的到达。
 * 4. SynchronousQueue 的主要应用场景包括：
 *  1. 消息队列：在消息队列中，当一个消息被发送到队列中时，需要立即被消费，而不需要等待其他消息的到达。
 *  2. 缓存：在缓存中，当一个元素被添加到缓存中时，需要立即被消费，而不需要等待其他元素的到达。
 *  3. 任务调度：在任务调度中，当一个任务被调度时，需要立即被执行，而不需要等待其他任务的到达。
 *  4. 其他场景：在某些特殊的场景下，需要实时处理任务，而线程池中的线程数量可以动态调整，以适应任务的实时性要求。
 *  5. SynchronousQueue 的主要缺点是，如果线程池中的线程数量已经达到最大值，并且没有任务可以执行，那么新的任务将会被拒绝。
 *  6. SynchronousQueue 的使用场景：在需要实时处理任务的场景中，例如消息队列、缓存、任务调度等，可以结合线程池和 SynchronousQueue 来实现。
 *  7. SynchronousQueue 的使用示例：
 *  1. 消息队列：使用 SynchronousQueue 作为消息队列的缓冲区，当一个消息被发送到队列中时，需要立即被消费，而不需要等待其他消息的到达。
 *  2. 缓存：使用 SynchronousQueue 作为缓存的缓冲区，当一个元素被添加到缓存中时，需要立即被消费，而不需要等待其他元素的到达。
 *  3. 任务调度：使用 SynchronousQueue 作为任务调度的缓冲区，当一个任务被调度时，需要立即被执行，而不需要等待其他任务的到达。
 *  4. 其他场景：在某些特殊的场景下，需要实时处理任务，而线程池中的线程数量可以动态调整，以适应任务的实时性要求。
 *  5. SynchronousQueue 的使用注意事项：在使用 SynchronousQueue 时，需要考虑以下注意事项：
 *  1. SynchronousQueue 的使用要求：在使用 SynchronousQueue 时，需要满足以下要求：
 *    a. 线程池中的线程数量必须大于等于1，否则无法执行任务。
 *    b. SynchronousQueue 的使用场景：在需要实时处理任务的场景中，例如消息队列、缓存、任务调度等，可以结合线程池和 SynchronousQueue 来实现。
 *
 *
 * @version: 1.0
 */
public class PoolTest04 {

	public static void main(String[] args) throws InterruptedException {
		ThreadPoolExecutor threadPoolExecutor = null;

		try {
			// 创建线程池对象
			threadPoolExecutor = new ThreadPoolExecutor(2, 3, 1, TimeUnit.SECONDS,
	     new SynchronousQueue<>()
			);

			// 创建任务
			Runnable r = () -> {
				try {
					TimeUnit.SECONDS.sleep(1);
				} catch (InterruptedException e) {
					e.printStackTrace();
				}
				System.out.println("线程池中的线程：" + Thread.currentThread().getName());
			};

			// 将任务交给线程池
			for (int i = 0; i < 4; i++) {
				threadPoolExecutor.execute(r);
			}
		} finally {
			// 关闭线程池
			if(threadPoolExecutor != null) {
				threadPoolExecutor.shutdown(); // 队列中的任务耗时非常长
				// 等待1秒, 如果还没有完成，则强制关闭
				if (!threadPoolExecutor.awaitTermination(10, TimeUnit.SECONDS)) {
					threadPoolExecutor.shutdownNow();
				}
			}
		}

//		System.out.println(threadPoolExecutor);
//
//		TimeUnit.SECONDS.sleep(10);
//		System.out.println(threadPoolExecutor);
//		// 关闭线程池
//		threadPoolExecutor.shutdown();
//		try {
//			if (!threadPoolExecutor.awaitTermination(1, TimeUnit.MINUTES)) {
//				threadPoolExecutor.shutdownNow(); // 如果超时未完成，则强制关闭
//			}
//		} catch (InterruptedException e) {
//			threadPoolExecutor.shutdownNow(); // 中断时强制关闭
//		}
	}
}
